    
    TestCase
    (
        'ie.ondevice.objectkit.FunctionInheritTestCase'

    ,   {
            testSimpleInheritance: function () 
            {
                var A= new Function
                ,   B= new Function
                
                
                assertFalse('Class A and B are unrelated', A.prototype.isPrototypeOf(B.prototype));
                B.inherit(A);
                // determine if A's prototype is the protoype of B's prototype
                assertTrue('Class B now inherits from A', A.prototype.isPrototypeOf(B.prototype));
                
                assertInstanceOf('B is an instanceof A', A, new B);
                assertFalse('A is not an instance of B', new A instanceof B);
            }
            
        ,   testParentPropertyAfterInherit: function () 
            {
                function A () 
                {
                    
                };
                
                function B () 
                {
                    
                };
                
                assertUndefined('No parent property exists before inherit is invoked', B.prototype.parent);
                
                B.inherit(A);
                
                assertSame('B.prototyp.parent is A.prototype', B.prototype.parent, A.prototype);
            }
            
            
        ,   testInvalidParent: function () 
            {
                 var Parent= null
                 ,   error
                 
                 function Constructor () {};
                 
                 function B () {};
                 function C () {};
                 
                 try 
                 {
                     Constructor.inherit(Parent);
                 }
                 catch (thrown) 
                 {
                     error= thrown;
                 }   
                 
                 assertNotNull('An error was thrown as null is invalid', error);
                 assertInstanceOf('A type error was thrown', TypeError, error);
                 
                 error= null
                 
                 try 
                 {
                     Constructor.inherit(Constructor);
                 }
                 catch (thrown) 
                 {
                     error= thrown;
                 }   
                 
                 assertNotNull('An error was thrown as a constructor cannot inherit from itself is invalid', error);
                 assertInstanceOf('A type error was thrown', TypeError, error);
            }
        }
    );